home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 147 / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan).7z / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan) (Track 1).bin / tools / zmc3v078 / zmc3v078.lzh / SRCSV078.LZH / $‾PARS‾1.C next >
C/C++ Source or Header  |  2000-05-09  |  35KB  |  1,532 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <ctype.h>
  4. #include <string.h>
  5.  
  6. #include "switch.h"
  7. #include "makezmd.h"
  8. #include "makezmd2.h"
  9. #include "velo.h"
  10. #include "etc.h"
  11. #include "68lib.h"
  12.  
  13. /* #define    MAXTRK        (80 + 1) */        /* includes from makezmd.h */
  14. /* #define    MAXTRK        (80) */
  15. /* #define    COMNTRKSIZE    8192 */
  16.  
  17.  
  18. #include "structs.h"
  19. #include "structs2.h"
  20. void resetError(void);
  21. inline LINEDATA *incrementLine(LINEDATA *ld);
  22. UBYTE *skipComment(UBYTE *zms);
  23. UBYTE *skipSpc(UBYTE *zms);
  24. UBYTE *skipSpcCr(UBYTE *zms);
  25. UBYTE *skipLine(UBYTE *zms);
  26. int stricmp2(char *str1,const char *str2);
  27. void zmserror(const char *errormes,int line,char *linebuf,char *zms,int warnlvl,int putzms);
  28. UBYTE *getnum2(UBYTE *zms,DWORD *num,int *err);
  29. UBYTE *getnum4(UBYTE *zms,DWORD *num,int *err,const char *spara[],int start);
  30. UBYTE *setex(UBYTE *zmd, UBYTE *data, DWORD len, int mode);
  31. UBYTE *txt2bin(UBYTE *zmd, UBYTE *zms,DWORD *zmsbyte);
  32. UBYTE *exclusive(UBYTE *zmd, UBYTE *zms,UBYTE f0f7, DWORD *zmsskip,
  33.                     const int ifno, const char *cmnt,
  34.                     UBYTE roland,UBYTE dev,UBYTE mdl,
  35.                     DWORD postlen, UBYTE *postdata,
  36.                     char *leftbrace,char *rightbrace);
  37. UBYTE *skiptochr(UBYTE *zms,const char *skip);
  38. UBYTE *skipchr(UBYTE *zms,const char *skip);
  39. UBYTE *getStep(UBYTE *zms, UWORD *step, UWORD Step,int *err,COMMONINF *cominf);
  40. UBYTE *getpara(UBYTE *zms, VELOETCVAR v[], int *paras, const int mustover0);
  41. UBYTE *getvpara(UBYTE *zms, VELOETCVAR **vp, int *paras);
  42. UBYTE *get1AbsPara(UBYTE *zms,DWORD *para,DWORD rangefrom,DWORD rangeto,
  43.                     char *outofrange,char *omitpara);
  44. UBYTE *setTie(UBYTE *zms,TRKCHINF *trkdata,const int Trk,TRKINF *trkinf,
  45.                 UBYTE note,UWORD *step, UWORD *gate, int relvelo, int omitgate,
  46.                 UWORD Step,COMMONINF *cominf,WORD velo);
  47. UBYTE *setTie2(UBYTE *zms,TRKCHINF *trkdata,const int Trk,TRKINF *trkinf,
  48.                 UBYTE note,UWORD step, UWORD gate, int relvelo, int portchordflg,
  49.                 WORD velo);
  50. UBYTE *set98Tie(UBYTE *zms, UWORD *step, UWORD Step,COMMONINF *cominf, int *err);
  51. UWORD getGate1(const int Trk,TRKINF *trkinf,UWORD Step);
  52. UWORD getGate2(WORD qvar,BYTE qrel,UWORD Step, WORD gtreso);
  53. void checkRenpu(TRKCHINF *trkdata, const int Trk,TRKINF *trkinf,int pflg);
  54. UBYTE *makeRenpuStepGate(UBYTE *zms, const BYTE target[],TRKCHINF *trkdata,TRKINF *trkinf,
  55.                         COMMONINF *cominf);
  56. /* void makePortBresemhamPara(WORD br,WORD *add,WORD *cor,UWORD step); */
  57. void setVelocitySequenceMode(TRKINF *trkinf,const BYTE trk,int mode);
  58. inline void recoverSpecialVelocity(TRKINF *trkinf, int Trk);
  59. UBYTE *checkOctaveChange(UBYTE *zms,TRKINF *trkinf,const int Trk);
  60. void incrementStepCounters(TRKINF *trkinf, UWORD step);
  61. int putZvar(UBYTE *zmd, DWORD var);
  62. DWORD getZvar(UBYTE *zmd);
  63. int putStepGate(UBYTE *zmd, RENP *r, UWORD step, UWORD gate);
  64. void freeAllChord(CHKCHORD *c);
  65. UBYTE *getChordGatePos(UBYTE *zmdbuf, DWORD gatepos, DWORD renpnotes);
  66.  
  67.  
  68.  
  69. extern DWORD line;
  70. extern char *linebuf;
  71. static char *zms__ = NULL;
  72. extern char *infile;
  73. extern LINEDATA *ld;
  74. extern LINEFILEDATA *lfd;
  75.  
  76.  
  77. void resetError(void)
  78. {
  79.     zms__ = NULL;
  80. }
  81.  
  82.  
  83. inline LINEDATA *incrementLine(LINEDATA *ld)
  84. {
  85.     if (ld->next) {
  86.         ld = ld->next;
  87.     }
  88.     return ld;
  89. }
  90.  
  91.  
  92. UBYTE *skipComment(UBYTE *zms)
  93. {
  94.     while(*zms != 0x0d && *zms != 0x0a) {
  95. /*
  96.         if (*zms == 0xff && *(zms + 1) == 0xff) {
  97.             break;
  98.         }
  99. */
  100.         zms++;
  101.     }
  102.     if (*zms == 0x0d && *(zms + 1) == 0x0a) {
  103.         zms += 2;
  104.     } else {
  105.         zms++;
  106.     }
  107.     linebuf = zms;
  108.     line++;
  109.     ld = incrementLine(ld);
  110.  
  111.     return zms;
  112. }
  113.  
  114. UBYTE *skipSpc(UBYTE *zms)
  115. {
  116.     const unsigned char *sp2 = "　";    /* Japanese specified WIDE SPACE character */
  117.  
  118.     while (*zms == ' ' || *zms == '\t' || *zms == '/' ||
  119.             (*zms == *sp2 && *(zms + 1) == sp2[1]) ) {
  120.         if (*zms == '/') {
  121.             zms = skipComment(zms);
  122.         } else if (*zms == *sp2) {
  123.             if (*(zms + 1) == sp2[1]) {
  124.             zms += 2;
  125.             }
  126.         } else {
  127.             zms++;
  128.         }
  129.     }
  130.     return zms;
  131. }
  132.  
  133.  
  134.  
  135. /* ================================
  136.      skip "space" and "return"
  137.    ================================ */
  138.  
  139. UBYTE *skipSpcCr(UBYTE *zms)
  140. {
  141.     const unsigned char *sp2 = "　";
  142.     while (1) {
  143.         switch (*zms) {
  144.             case 0xff:
  145.                 if (*(zms + 1) == 0xff) {
  146.                     goto EXITSKIPSPCCRLOOP;
  147.                 }
  148.                 break;
  149.             case 0x0d:
  150.                 if (*(zms + 1) == 0x0a) {
  151.                     /* zms += 2; */
  152.                     zms++;
  153.                 }
  154.                 /* NO BREAK */
  155.             case 0x0a:
  156.                 linebuf = ++zms;
  157.                 line++;
  158.                 ld = incrementLine(ld);
  159.                 break;
  160.             case '/':
  161.                 zms = skipComment(zms);
  162.                 break;
  163.             case ' ':
  164.             case '\t':
  165.                 zms++;
  166.                 break;
  167.             default:
  168.                 if (*zms == sp2[0] && *(zms + 1) == sp2[1]) {
  169.                     zms += 2;
  170.                     break;
  171.                 }
  172.                 goto EXITSKIPSPCCRLOOP;
  173.                 /* break; */
  174.         }
  175.     }
  176. EXITSKIPSPCCRLOOP:
  177.     return zms;
  178. }
  179.  
  180.  
  181. /* =================
  182.      skip the line
  183.    ================== */
  184.  
  185. UBYTE *skipLine(UBYTE *zms)
  186. {
  187.     while (1) {
  188.         switch (*zms) {
  189.             case 0xff:
  190.                 if (*(zms + 1) == 0xff) {
  191.                     goto EXITSKIPSPCCRLOOP;
  192.                 }
  193.                 break;
  194.             case 0x0d:
  195.                 if (*(zms + 1) == 0x0a) {
  196.                     /* zms += 2; */
  197.                     zms++;
  198.                 }
  199.                 /* NO BREAK */
  200.             case 0x0a:
  201.                 linebuf = ++zms;
  202.                 line++;
  203.                 ld = incrementLine(ld);
  204.                 goto EXITSKIPSPCCRLOOP;
  205.                 break;
  206.             default:
  207.                 zms++;
  208.                 break;
  209.         }
  210.     }
  211. EXITSKIPSPCCRLOOP:
  212.     return zms;
  213. }
  214.  
  215.  
  216. /* ======================================================
  217.      strings compare, (it must be strlen(str1) >= strlen(str2) )
  218.    ====================================================== */
  219.  
  220. int stricmp2(char *str1,const char *str2)
  221. {
  222.     /* const int len1 = strlen(str1); */
  223.     const int len2 = strlen(str2);
  224.     /* char s1[1024]; */
  225.     char tmp;
  226.     int rc;
  227.  
  228.     /* s1 = (char*)emalloc(sizeof(char) * len1 + 1); */
  229. /*
  230.     strncpy(s1,str1,len2);
  231.     s1[len2] = '\0';
  232. */
  233.     tmp = str1[len2];
  234.     str1[len2] = '\0';
  235.     rc = stricmp(str1,str2);        /* caseless strings compare */
  236.  
  237.     /* efree(s1); */
  238.     str1[len2] = tmp;
  239.     return rc;
  240. }
  241.  
  242.  
  243. /* =========
  244.      ERROR
  245.      warnlvl: 0=err 1- warn level
  246.    ========= */
  247.  
  248. void zmserror(const char *errormes,int line,char *linebuf,char *zms,int warnlvl,int putzms)
  249. {
  250.     char *str, *p = linebuf;
  251.     int i,len,len2 = zms - linebuf;
  252.  
  253.     while (*p != 0x0d && *p != 0x0a && *p != 0x1a && *p != (char)-1) {
  254.         p++;
  255.     }
  256.     /* p = skipComment(linebuf); */
  257.     len = p - linebuf;        /* len: length of zmsline */
  258.  
  259.     if (!getSwitchVal('w') || (zms__ != zms && getSwitchVal('w') >= warnlvl)) {
  260.         char *p,*em;
  261.  
  262.         em = emalloc(sizeof(char) * (strlen(errormes) + 16),"em");
  263.         if (warnlvl) {
  264.             strcpy(em,"Warning: ");
  265.         } else {
  266.             strcpy(em,"Error: ");
  267.         }
  268.         strcat(em,errormes);
  269.  
  270.         zms__ = zms;
  271.         str = emalloc(sizeof(char) * (len + 1),"str_in_zmserror");
  272.         if (len) {
  273.             strncpy(str,linebuf,len);
  274.         }
  275.         str[len] = '\0';
  276.  
  277.         p = str - 1;
  278.         while (*++p) {
  279.             if (*p == 0x1a) {
  280.                 *p = '\0';
  281.             }
  282.         }
  283.  
  284.         if (getSwitchVal('l') != SET_VAL) {
  285. /*            fprintf(stderr,"%s\t%d: %s\n",infile,line,em); */
  286.             fprintf(stderr,"%s\t%d: %s\n", ld->filename, ld->line, em);
  287.         } else {
  288. /*            fprintf(stderr,"%s\tL%dC%d: %s\n",infile,line,len2 + 1,em); */
  289.             fprintf(stderr,"%s\tL%dC%d: %s\n", ld->filename, ld->line, len2 + 1, em);
  290.         }
  291.         if (putzms) {
  292.             fprintf(stderr,"%s\n",str);
  293.             for (i = 0; i < len2; i++) {
  294.                 if (str[i] == '\t') {
  295.                     fprintf(stderr,"\t");
  296.                 } else {
  297.                     fprintf(stderr," ");
  298.                 }
  299.             }
  300.             fprintf(stderr,"^\n");
  301.         }
  302.         efree(str,"str");
  303.         efree(em,"em");
  304.  
  305.         if (!warnlvl) {
  306.             exit(1);
  307.         }
  308.     }
  309. }
  310.  
  311.  
  312.  
  313. /* =======================================
  314.      text->numeric conversion
  315.      $xx , %xxxx are OK,too
  316.      *err= 0: no err
  317.            1: SYNTAX ERR
  318.           -1: no value
  319.    ======================================== */
  320.  
  321. UBYTE *getnum2(UBYTE *zms,DWORD *num,int *err)
  322. {
  323.     BYTE    sign    = 1;
  324.     BYTE    binhex  = 10;
  325.     BYTE    novalue = 1;
  326.  
  327.     *num = *err = 0;
  328.     zms = skipSpcCr(zms);
  329.     for (;;) {
  330.         switch (*zms) {
  331.             case '+':
  332.                 if (novalue) {
  333.                     zms++;
  334.                 } else {
  335.                     goto SWLOOPEND;
  336.                 }
  337.                 break;
  338.             case '-':
  339.                 if (novalue) {
  340.                     sign = -1;
  341.                     zms++;
  342.                 } else {
  343.                     goto SWLOOPEND;
  344.                 }
  345.                 break;
  346.             case '%':
  347.                 binhex = 2;
  348.                 zms++;
  349.                 break;
  350.             case '$':
  351.                 binhex = 16;
  352.                 zms++;
  353.                 break;
  354.             case '0':    case '1':
  355.             case '2':    case '3':
  356.             case '4':    case '5':
  357.             case '6':    case '7':
  358.             case '8':    case '9':
  359.                 if (binhex == 2 && *zms >= '2') {
  360.                     *err = 1;
  361.                     goto SWLOOPEND;
  362.                 }
  363.                 *num *= binhex;
  364.                 *num += *zms++ - '0';
  365.                 novalue = 0;
  366.                 break;
  367.             case 'a':    case 'A':
  368.             case 'b':    case 'B':
  369.             case 'c':    case 'C':
  370.             case 'd':    case 'D':
  371.             case 'e':    case 'E':
  372.             case 'f':    case 'F':
  373.                 /* *zms |= 0x20; */
  374.                 if (binhex != 16) {        /* e.g.: c1a */
  375.                     /* *err = 1; */
  376.                     goto SWLOOPEND;
  377.                 }
  378.                 *num *= 16;
  379.                 *num += tolower(*zms++) - 'a' + 10;
  380.                 novalue = 0;
  381.                 break;
  382.             case ' ':
  383.             case '\t':
  384.                 if (novalue) {
  385.                     zms++ ;
  386.                     zmserror("illegal space.",line,linebuf,zms,3,1);
  387.                     break ;
  388.                 }
  389.             default:
  390.                 goto SWLOOPEND;
  391.                 /* break; */
  392.         }
  393.     }
  394. SWLOOPEND:
  395.     if (novalue) {
  396.         if (sign == -1 || binhex != 10) {
  397.             *err = 1;
  398.         } else {
  399.             *err = -1;
  400.         }
  401.     }
  402.     *num *= sign;
  403.  
  404. /* printf("[%d %d]",*num,*err); */
  405.     return zms;
  406. }
  407.  
  408.  
  409.  
  410. UBYTE *getnum4(UBYTE *zms,DWORD *num,int *err,const char *spara[], int start)
  411. {
  412.     int p = 0 - 1;
  413.  
  414.     zms = skipSpc(zms);
  415.     *err = -1;
  416.     while (spara[++p]) {
  417.         if (!stricmp2(zms, spara[p])) {
  418.             *num = p + start;
  419.             *err = 0;
  420.             zms += strlen(spara[p]);
  421.             break;
  422.         }
  423.     }
  424.     if (*err < 0) {
  425.         zms = getnum2(zms,num,err);
  426.         if (*err > 0) {
  427.             zmserror("parameter error.",line,linebuf,zms,0,1);
  428.         }
  429.     }
  430.     return zms;
  431. }
  432.  
  433. /* ===========================================================
  434.      exclusive(low level)
  435.      put "data"s simply. ("len" bytes)
  436.      put Roland/YAMAHA Exclusive additionaly (if "mode" is set.)
  437.      mode=1: Roland
  438.      mode=2: YAMAHA
  439.      mode=4: YAMAHA(DX)
  440.    =========================================================== */
  441.  
  442. UBYTE *setex(UBYTE *zmd, UBYTE *data, DWORD len, int mode)
  443. {
  444.     DWORD i;
  445.     UBYTE sum = 0;
  446.  
  447.     if (mode == 1 || mode == 2 || mode == 4) {    /* with Roland/YAMAHA checksum */
  448.         const DWORD exceptsum = (mode == 1)? 5 : 4;
  449.         for (i = 0; i < exceptsum; i++) {        /* ID,dev,etc.. */
  450.             *zmd++ = *data++;
  451.         }
  452.         if (mode == 2 || mode == 4) {    /* for YAMAHA: add block size */
  453.             DWORD bytecount = len - exceptsum;
  454.             if (mode == 2) {
  455.                 bytecount -= 3;        /* for address */
  456.             }
  457.             /* putWord(zmd, len - exceptsum - 3); */
  458.             *zmd = (bytecount >> 7) & 0x7F;
  459.             if (mode == 2) {
  460.                 sum -= *zmd++;
  461.             } else {
  462.                 zmd++;
  463.             }
  464.             *zmd = bytecount & 0x7F;
  465.             if (mode == 2) {
  466.                 sum -= *zmd++;
  467.             } else {
  468.                 zmd++;
  469.             }
  470.         }
  471.         for (i = exceptsum; i < len; i++) {
  472.             *zmd++ = *data;
  473.             sum -= *data++;
  474.         }
  475.         *zmd++ = sum & 0x7f;
  476.     } else {
  477.         for (i = 0; i < len; i++) {
  478.             *zmd++ = *data++;
  479.         }
  480.     }
  481.  
  482.     return zmd;
  483. }
  484.  
  485.  
  486. /* ========================================
  487.      text->binary conversion
  488.      "strings" supports.
  489.      week point: poor error check
  490.    ======================================== */
  491.  
  492. UBYTE *txt2bin(UBYTE *zmd, UBYTE *zms, DWORD *zmsbyte)
  493. {
  494.     UBYTE *zms_ = zms;
  495.     DWORD bytes;
  496.     int err;
  497.     DWORD num;
  498.  
  499.     zms = getnum2(zms,&num,&err);
  500. /* printf("(%d %d)",num,err); */
  501.     bytes = zms - zms_;
  502.     if (err < 0 && *zms == '\"') {                            /* "strings" */
  503.         zms++;
  504.         bytes++;
  505.         while (*zms != '\"' && *zms != '\n') {
  506.             *zmd++ = *zms++;
  507.             bytes++;
  508.             if (*zms == 0xff && *(zms + 1) == 0xff) {
  509.                 break;
  510.             }
  511.         }
  512.         /* zms++; */    /* no need */
  513.         bytes++;
  514.     } else if (!err) {                                        /* numerics */
  515.         if (num >= 256) {
  516.             do {
  517.                 *zmd++ = num & 0x7f;
  518.                 num >>= 7;
  519.             } while (num);
  520.         } else {
  521.             *zmd++ = num;
  522.         }
  523.     } else if (*zms == ',') {
  524.         /* bytes = -1; */
  525.     }
  526.  
  527.     *zmsbyte = bytes;
  528.     return zmd;
  529. }
  530.  
  531.  
  532.  
  533.  
  534.  
  535. UBYTE *exclusive(UBYTE *zmd, UBYTE *zms,UBYTE f0f7, DWORD *zmsskip,
  536.                     const int ifno, const char *cmnt,
  537.                     UBYTE roland,UBYTE dev,UBYTE mdl,
  538.                     DWORD postlen, UBYTE *postdata,
  539.                     char *leftbrace,char *rightbrace)
  540. {
  541.     /* roland == 0:no vendor infomation
  542.                  1:Roland
  543.                  2:YAMAHA w/ sum
  544.                  3:YAMAHA w/o sum
  545.                  4:DX (w/ sum, sum doesn't include bytecount)
  546.      */
  547.  
  548.     int        len,len2;
  549.     DWORD zmsbyte = 0;
  550.     UBYTE *data = (UBYTE*)emalloc(sizeof(UBYTE) * 8192, "data_in_exclusive");
  551.     UBYTE *data_ = data;
  552.     UBYTE *zms_  = zms;
  553.     int lbflg = 0;
  554.  
  555.     if (f0f7) {
  556.         *data++ = 0xf0;
  557.     }
  558.     if (roland == 1) {
  559.         *data++ = 0x41;                /* Roland maker ID */
  560.         *data++ = dev;
  561.         *data++ = mdl;
  562.         *data++ = 0x12;
  563.     } else if (roland == 2 || roland == 3 || roland == 4) {
  564.         *data++ = 0x43;                /* YAMAHA maker ID */
  565.         *data++ = dev;
  566.         *data++ = mdl;
  567.     }
  568.     if (postlen) {
  569.         for (len = 0; len < postlen; len++) {
  570.             *data++ = *postdata++;
  571.         }
  572.     }
  573.  
  574.     if (*leftbrace) {
  575. #ifdef __GNUC__
  576.         char skip[2] = { *leftbrace, '\0' };
  577. #else
  578.         char skip[2] = { '\0','\0' };
  579.  
  580.         skip[0] = *leftbrace;
  581. #endif
  582.         zms = skiptochr(zms,skip);
  583.         if (!zms || *zms == 0xFF) {
  584.             zmserror("unexpected EOF.",line,linebuf,zms,0,1);
  585.         } else if (*zms++ != *leftbrace) {
  586.             char str[128];
  587.             sprintf(str,"`%s' not found.",*leftbrace);
  588.             zmserror(str,line,linebuf,zms,0,1);
  589.         }
  590.     } else {
  591.         zms = skipSpcCr(zms);
  592.     }
  593.  
  594.     if (*leftbrace == '\"') {
  595.         zms--;
  596.         lbflg = 1;
  597.     }
  598.  
  599.     while (*zms != rightbrace[0] || lbflg) {
  600.         lbflg = 0;
  601.         data = txt2bin(data,zms,&zmsbyte);
  602.         if (zmsbyte >= 0) {        /* if not ',' */
  603.             zms += zmsbyte;
  604.             if (*leftbrace == '\"' && strlen(leftbrace) == 1) {
  605.                 /* only "..." strings is allowed ... .sc55_print etc.*/
  606.                 zms--;
  607.             }
  608.         }
  609. /*printf("%c",*zms); */
  610.         if (*zms == '/') {
  611.             zms = skipComment(zms);
  612.         }
  613.         if (!strchr(rightbrace, *zms)) {
  614.             /* char str[128]; */
  615.             /* sprintf(str,"%.2x: illegal partion character.",*zms); */
  616.             zmserror("illegal partition character.",line,linebuf,zms,0,1);
  617.         }
  618.         if (*zms == ',') {        /* if ',' */
  619.             zms++;
  620.         } else if (*zms == 0xFF && *(zms + 1) == 0xFF) {    /* EOF */
  621.             zmserror("unexpected EOF.",line,linebuf,zms,0,1);
  622.         }
  623.         if (*leftbrace == '\"') {
  624.             break;
  625.         }
  626.     }
  627.  
  628.  
  629.     *zmd++ = 0x34;                                /* MIDI DATA transfer */
  630.     *zmd++ = ifno;                                /* IF number: (-1 == current IF) */
  631.     if (cmnt) {
  632.         *zmd++ = strlen(cmnt);                    /* comment length */
  633.         strcpy(zmd, cmnt);
  634.         zmd += strlen(cmnt);
  635.     } else {
  636.         *zmd++ = 0;
  637.     }
  638.     len2 = len = data - data_;
  639.     if (f0f7) {
  640.         len2++;                                    /* len + 1:for 0xF7 */
  641.     }
  642.     if (roland == 1) {
  643.         len2++;                                    /* for checksum */
  644.     } else if (roland == 2) {
  645.         len2 += 3;                                /* for ByteCount(2) + checksum(1) */
  646.     } else if (roland == 4) {
  647.         len2 += 3;                                /* for ByteCount(2) + checksum(1) */
  648.     }
  649.     putDword(zmd, len2);
  650.     zmd += 4;
  651.     zmd = setex(zmd, data_, len, roland);
  652.     if (f0f7) {
  653.         *zmd++ = 0xf7;
  654.     }
  655.  
  656.     efree(data_,"data_");
  657.  
  658.     *zmsskip = zms - zms_ + 1;
  659.     return zmd;
  660. }
  661.  
  662.  n
  663.  
  664.  
  665.  
  666.  
  667.  
  668. /* ==========================
  669.      scan texts "until" skip_characters comes.
  670.      if feof, return NULL.(means ERROR)
  671.    ==========================  */
  672.  
  673. UBYTE *skiptochr(UBYTE *zms,const char *skip)
  674. {
  675.     while ( *zms != 0xFF && !strchr(skip, *zms) ) {
  676.         if (*zms == 0x0d) {
  677.             if (*(zms + 1) == 0x0a) {
  678.                 zms += 2;
  679.             } else {
  680.                 zms++;
  681.             }
  682.             linebuf = zms;
  683.             line++;
  684.             ld = incrementLine(ld);
  685.         } else if (*zms == 0x0a) {
  686.             linebuf = ++zms;
  687.             line++;
  688.             ld = incrementLine(ld);
  689.         } else {
  690.             zms++;
  691.         }
  692.     }
  693.     if (*zms == 0xFF && *(zms + 1) == 0xFF) {
  694.         return NULL;
  695.     } else {
  696.         return zms;
  697.     }
  698. }
  699.  
  700.  
  701. /* ==========================
  702.      scan texts "while" skip_characters comes.
  703.      if feof, return NULL.(means ERROR)
  704.    ==========================  */
  705.  
  706. UBYTE *skipchr(UBYTE *zms,const char *skip)
  707. {
  708.     while ( *zms != 0xFF && strchr(skip, *zms) ) {
  709.         if (*zms == 0x0d) {
  710.             if (*(zms + 1) == 0x0a) {
  711.                 zms += 2;
  712.             } else {
  713.                 zms++;
  714.             }
  715.             linebuf = zms;
  716.             line++;
  717.             ld = incrementLine(ld);
  718.         } else if (*zms == 0x0a) {
  719.             linebuf = ++zms;
  720.             line++;
  721.             ld = incrementLine(ld);
  722.         } else {
  723.             zms++;
  724.         }
  725.     }
  726.     if (*zms == 0xFF && *(zms + 1) == 0xFF) {
  727.         return NULL;
  728.     } else {
  729.         return zms;
  730.     }
  731. }
  732.  
  733.  
  734.  
  735. UBYTE *getStep(UBYTE *zms, UWORD *step, UWORD Step,int *err_,COMMONINF *cominf)
  736. {
  737.     UWORD step_ = 0;
  738.     int err;
  739.     DWORD para;
  740.     *err_ = 0;
  741.  
  742.     zms = getnum2(zms,¶,&err);        /* step parameter */
  743.     if (!err) {
  744.         step_ = (para)? cominf->div / para : 0;
  745.                                         /* quaternote etc.. (not set ticks directly) */
  746.     } else if (err < 0) {
  747.         if (*zms == '*') {                /* set ticks directry */
  748.             zms = getnum2(++zms,¶,&err);
  749.             if (err) {
  750.                 zmserror("`*' must be followed to its parameter.",line,linebuf,zms,0,1);
  751.             }
  752.             step_ = para;
  753.         } else {                        /* no parameters */
  754.             step_ = Step;
  755.             *err_ = 2;
  756.         }
  757.     } else {
  758.         zmserror("SYNTAX ERROR",line,linebuf,zms,0,1);
  759.     }
  760.     para = step_;                        /* "."(dots) */
  761.     while (*zms == '.') {
  762.         para /= 2;
  763.         step_ += para;
  764.         zms = skipSpc(++zms);
  765.         *err_ = 1;
  766.     }
  767.     *step = step_;
  768.  
  769.     return zms;
  770. }
  771.  
  772.  
  773.  
  774. /* ===========================
  775.      get parameter (1/8 series)
  776.    =========================== */
  777.  
  778. UBYTE *getpara(UBYTE *zms, VELOETCVAR v[], int *paras, const int mustover0)
  779. {
  780.     DWORD velo = 127,znum = 0;
  781.     int i,err;
  782.  
  783.     zms--;
  784.     do {
  785.         BYTE rel;
  786.         int znumadd = 0;
  787.         for (i = 0; i < 2; i++) {                    /* i==  0:velo 1:randompara */
  788.             zms = skipSpcCr(zms + 1);
  789.             /* if (i != 0 && (*zms == '+' || *zms == '-')) { */
  790.             if (*zms == '+' || *zms == '-') {
  791.                 rel = 1;
  792.             } else {
  793.                 rel = 0;
  794.             }
  795.             zms = getnum2(zms,&velo,&err);
  796.             if (err < 0) {                            /* omit 1st/Xth parameter */
  797.                 if (znum != 0) {
  798.                     v[znum].var[i]    = v[znum - 1].var[i];
  799.                 }
  800.                 v[znum].relflg[i] = 2;                /* set "omit-flg" */
  801.                 if (*zms == ',' /*|| *zms == ':'*/) {    /* continue.. */
  802.                     znumadd = 1;
  803.                     /* v[0].var[i]    = 0; */
  804.                     /* v[znum].relflg[i] = 2; */    /* set "omit-flg" */
  805.                     /* znum = 1; */
  806.                 } else {                            /* that's all */
  807. /* printf("[V=%d]",velo); */
  808.                     /* znum = 0; */
  809.                 }
  810.             } else {                                /* there is 1st/Xth parameter */
  811.                 if (mustover0 && !velo) {
  812.                     zmserror("This parameter must be over 0.",line,linebuf,zms,0,1);
  813.                 }
  814.                 v[znum].var[i] = velo;
  815.                 v[znum].relflg[i] = rel;
  816.                 znumadd = 1;
  817.             }
  818.  
  819.             /* printf("[V=%d]",velo); */
  820.             zms = skipSpcCr(zms);
  821.             if (*zms != ':' || (*zms == ':' && *(zms + 1) == '|')) {
  822.                 int j;
  823.                 for (j = i + 1; j < 2; j++) {
  824.                     v[znum].var[j]    = 0;
  825.                     v[znum].relflg[j] = -1;
  826.                 }
  827.                 break;
  828.             }
  829.         }
  830.         znum += znumadd;
  831.     } while (*zms == ',');
  832.  
  833.     *paras = znum;
  834.     if (znum > 0 && v[znum - 1].relflg[0] == 2) {        /* if the last parameter is omitted */
  835.         (*paras)--;
  836.     }
  837.  
  838.     return zms;
  839. }
  840.  
  841.  
  842.  
  843.  
  844. /* ===========================
  845.      get variable length parameter
  846.    =========================== */
  847.  
  848. UBYTE *getvpara(UBYTE *zms, VELOETCVAR **vp, int *paras)
  849. {
  850.     DWORD znum = 0;
  851.     DWORD znummax = 8;
  852.     *vp = emalloc(sizeof(VELOETCVAR) * znummax,"vp_in_getvpara");
  853.     zms--;
  854.     do {
  855.         DWORD var;
  856.         int i,err;
  857.         BYTE rel;
  858.         for (i = 0; i < 2; i++) {
  859.             (*vp)[znum].var[i]    = 0;
  860.             (*vp)[znum].relflg[i] = -1;
  861.         }
  862.         for (i = 0; i < 2; i++) {
  863.             zms = skipSpcCr(zms + 1);
  864.             if (*zms == '*') {
  865.                 zms++;
  866.                 rel = 3;
  867.             } else {
  868.                 rel = (*zms == '+' || *zms == '-') ? 1 : 0;
  869.             }
  870.             zms = getnum2(zms,&var,&err);
  871.             if (err) {                        /* omit 1st/Xth parameter */
  872.                 var = (znum > 0) ? (*vp)[znum - 1].var[0] : 0;
  873.                 rel = 2;                    /* set "omit-flg" */
  874.             }
  875.             (*vp)[znum].var[i]    = var;
  876.             (*vp)[znum].relflg[i] = rel;
  877.             zms = skipSpcCr(zms);
  878.             if (*zms != ':' || *(zms + 1) == '|') break;
  879.         }
  880.         if (++znum == znummax) {
  881.             znummax += 8;
  882.             *vp = erealloc(*vp, sizeof(VELOETCVAR) * znummax,"vp_in_getvpara");
  883.         }
  884.         zms = skipSpcCr(zms);
  885.     } while (*zms == ',');
  886.     /* *vp = erealloc(*vp, sizeof(VELOETCVAR) * znum); */
  887.     if ((*vp)[znum - 1].relflg[0] == 2) {    /* if the last parameter is omitted */
  888.         znum--;
  889.     }
  890.     *paras = znum;
  891.     return zms;
  892. }
  893.  
  894.  
  895.  
  896. /* ==============================
  897.      get parameter(can't omit parameter, cant set parameter relatively)
  898.    ============================== */
  899.  
  900. UBYTE *get1AbsPara(UBYTE *zms,DWORD *para,DWORD rangefrom,DWORD rangeto,
  901.                     char *outofrange,char *omitpara)
  902. {
  903.     UBYTE *zms_ = zms;
  904.     DWORD line_ = line;
  905.     UBYTE *linebuf_ = linebuf;
  906. /*    LINEDATA *ld_ = ld; */
  907.     int err;
  908.  
  909.     zms = getnum2(zms,para,&err);
  910.     if (!err) {
  911.         if (rangefrom != rangeto && (*para < rangefrom || rangeto < *para)) {
  912.             zmserror(outofrange,line_,linebuf_,zms_,0,1);
  913.         }
  914.     } else {
  915.         zmserror(omitpara,line_,linebuf_,zms_,0,1);
  916.     }
  917.  
  918.     return zms;
  919. }
  920.  
  921.  
  922.  
  923.  
  924.  
  925. UBYTE *setTie(UBYTE *zms,TRKCHINF *trkdata,const int Trk,TRKINF *trkinf,
  926.                 UBYTE note,UWORD *step, UWORD *gate, int relvelo, int omitgate,
  927.                 UWORD Step,COMMONINF *cominf, WORD velo)
  928. {
  929.     int err;
  930.  
  931.     zms = skipSpcCr(zms);
  932.     zms = set98Tie(zms, step, Step, cominf, &err);
  933.     if ((omitgate == 2 && *gate != 0x8000) || err != 2) {    /* add v0.70: 0x8000 */
  934.         *gate = getGate1(Trk,trkinf,*step);
  935.     }
  936.  
  937.     {                            /* add v0.72 */
  938.         UWORD bakgate = *gate;
  939.         int err;
  940.         VELOETCVAR v;
  941.         BYTE relvelo;
  942.  
  943.         v.var[0] = 0;
  944.         v.relflg[0] = 2;
  945.  
  946.         /* gate */
  947.         zms = getGate(zms,Trk,trkinf,*step,gate,&err,cominf);
  948.         if (err == 2) {
  949.             *gate = bakgate;
  950.         }
  951.         /* zms = checkOctaveChange(zms,trkinf,Trk); */
  952.  
  953.         /* velo */
  954.         zms = getSpecialVelocity(zms,&v);
  955.         setVelo0(trkdata,Trk,v,&relvelo,trkinf,cominf,*step);
  956.     }
  957.  
  958.     zms = skipSpcCr(zms);
  959.     if (*zms == '&') {            /* tie */
  960.         *gate = 0x8000;
  961.         zms++;
  962.     }
  963.     zms = setTie2(zms,trkdata,Trk,trkinf,
  964.                 note,*step,*gate,relvelo,0,velo);
  965.  
  966.     return zms;
  967. }
  968.  
  969.  
  970.  
  971. UBYTE *setTie2(UBYTE *zms,TRKCHINF *trkdata,const int Trk,TRKINF *trkinf,
  972.                 UBYTE note,UWORD step, UWORD gate, int relvelo, int portchordflg,
  973.                 WORD velo)
  974. {
  975.     /* printf("[note,sgv,tie=%d,%d,%d,%d,%d]",note,step,*gate,velo,tie); */
  976.  
  977.     if (step == 0 && note != 0x80 && gate == 0) {            /* *0  */
  978.                                     /* && gate <= 1 */
  979.         *trkdata[Trk].zmd++ = 0xB2;
  980.         *trkdata[Trk].zmd++ = note;
  981.         /* *data++ = note; */
  982.  
  983.         if (relvelo == 0) {                    /* default velo */
  984.             *trkdata[Trk].zmd++ = 128;
  985.         } else if (relvelo > 0) {            /* relative velo */
  986.             if (abs(velo) > 63) {
  987.                 zmserror("relative velocity must be in from -63 to 63.",line,linebuf,zms,0,1);
  988.             }
  989.             *trkdata[Trk].zmd++ = 192 + velo;
  990.         } else {                            /* special velo */
  991.             int v = velo + trkinf[Trk].veloofst;
  992.             if (v > 127) {
  993.                 v = 127;
  994.             } else if (v < 0) {
  995.                 v = 0;
  996.             }
  997.             *trkdata[Trk].zmd++ = v;
  998.         }
  999.     } else {
  1000.         *trkdata[Trk].zmd++ = note;
  1001.         if (trkinf[Trk].renpnotes) {
  1002.             checkRenpu(trkdata,Trk,trkinf,portchordflg);
  1003.         }
  1004.         trkdata[Trk].zmd += putStepGate(trkdata[Trk].zmd, trkinf[Trk].r->prev,step,gate);
  1005. #ifdef A
  1006.         if (trkinf[Trk].r->prev) {        /* always 2byte while renpu */
  1007.             putWord(trkdata[Trk].zmd,     step);
  1008.             putWord(trkdata[Trk].zmd + 2, gate);
  1009.             trkdata[Trk].zmd += 4;
  1010.         } else {
  1011.             trkdata[Trk].zmd += putZvar(trkdata[Trk].zmd, step);
  1012.             trkdata[Trk].zmd += putZvar(trkdata[Trk].zmd, gate);
  1013.         }
  1014. #endif
  1015.         if (note != 0x80) {
  1016.             if (relvelo == 0) {                /* default velo */
  1017.                 *trkdata[Trk].zmd++ = 128;
  1018.             } else if (relvelo > 0) {        /* relative velo */
  1019.                 if (abs(velo) > 63) {
  1020.                     zmserror("relative velocity must be in from -63 to 63.",line,linebuf,zms,0,1);
  1021.                 }
  1022.                 *trkdata[Trk].zmd++ = 192 + velo;
  1023.             } else {                        /* special velo */
  1024.                 int v = velo + trkinf[Trk].veloofst;
  1025.                 if (v > 127) {
  1026.                     v = 127;
  1027.                 } else if (v < 0) {
  1028.                     v = 0;
  1029.                 }
  1030.             *trkdata[Trk].zmd++ = v;
  1031.             }
  1032.         }
  1033.  
  1034.         if (relvelo) {
  1035.             trkinf[Trk].spvelomode = 1;
  1036.             /* *trkdata[Trk].zmd++ = 0x84; */        /* recover special velocity */
  1037.         }
  1038.     }
  1039.     /* printf("[%d]",data - data_); */
  1040.  
  1041.     /* *data2 = data; */
  1042.     return zms;
  1043. }
  1044.  
  1045.  
  1046. UBYTE *set98Tie(UBYTE *zms, UWORD *step, UWORD Step,COMMONINF *cominf, int *err)
  1047. {
  1048.     *err = 2;        /* 2: no parameter 0: there is parameter */
  1049.  
  1050.     while (*zms == '^') {    /* 98 tie */
  1051.         UWORD addstep;
  1052.         int err_;
  1053.  
  1054.         zms = getStep(++zms, &addstep, Step, &err_,cominf);
  1055.         if (err_ != 2) {
  1056.             *err = 0;
  1057.         }
  1058.  
  1059.         *step += addstep;
  1060.         zms = skipSpcCr(zms);
  1061.     }
  1062.  
  1063.     return zms;
  1064. }
  1065.  
  1066.  
  1067. /* ======================================
  1068.      get gate without numeric parameter
  1069.    ====================================== */
  1070.  
  1071. UWORD getGate1(const int Trk,TRKINF *trkinf,UWORD Step)
  1072. {
  1073.     /* const int Trk = target[Trk]; */
  1074.     BYTE *qpos = &(trkinf[Trk].quantizepos);
  1075.     WORD qvar = trkinf[Trk].quantize[*qpos].var[0];
  1076.     BYTE qrel = trkinf[Trk].quantize[*qpos].relflg[0];
  1077.  
  1078.     return getGate2(qvar,qrel,Step, trkinf[Trk].gtreso);
  1079. }
  1080.  
  1081.  
  1082. UWORD getGate2(WORD qvar,BYTE qrel,UWORD Step, WORD gtreso)
  1083. {
  1084.     UWORD gate;
  1085.  
  1086.     if (qrel == 1) {
  1087.         if (qvar < 0 || Step > qvar) {
  1088.             gate = Step - qvar;
  1089.         } else {
  1090.             gate = Step;
  1091.         }
  1092.     } else if (qrel == 3) {
  1093.         if (Step < qvar) {
  1094.             gate = Step;
  1095.         } else {
  1096.             gate = qvar;
  1097.         }
  1098.     } else {
  1099.         gate = Step * qvar / gtreso;
  1100.         if (gate == 0 && Step != 0) {
  1101.             gate = 1;
  1102.         }
  1103.     }
  1104.  
  1105.     return gate;
  1106. }
  1107.  
  1108.  
  1109.  
  1110. void checkRenpu(TRKCHINF *trkdata, const int Trk,TRKINF *trkinf,int pflg)
  1111. {
  1112.     /* const int Trk = target[Trk]; */
  1113.     if (trkinf[Trk].renpnotes) {            /* renpu? */
  1114.         BYTE *qpos = &(trkinf[Trk].quantizepos);
  1115.         char s[32];
  1116.         sprintf(s,"trkinf[%d].r->next");
  1117.  
  1118.         trkinf[Trk].renpnotes++;
  1119.         trkinf[Trk].r->step       = trkdata[Trk].zmd - trkdata[Trk].zmdbuf;
  1120.         trkinf[Trk].r->qvar       = trkinf[Trk].quantize[*qpos].var[0];
  1121.         trkinf[Trk].r->qrelflg    = trkinf[Trk].quantize[*qpos].relflg[0];
  1122.         trkinf[Trk].r->pflg       = pflg;        /* ==1: portament */
  1123.                                                 /* ==2: chord */
  1124.         trkinf[Trk].r->next       = (RENP*)emalloc(sizeof(RENP) * 1,s);
  1125.         trkinf[Trk].r->next->prev = trkinf[Trk].r;
  1126.         trkinf[Trk].r             = trkinf[Trk].r->next;
  1127.         trkinf[Trk].r->next       = NULL;
  1128.     }
  1129. }
  1130.  
  1131.  
  1132. UBYTE *makeRenpuStepGate(UBYTE *zms, const BYTE target[],TRKCHINF *trkdata,TRKINF *trkinf,
  1133.                         COMMONINF *cominf)
  1134. {
  1135.     int trk;
  1136.     UBYTE *zms_ = zms;
  1137.     int warnoct = 0;
  1138.  
  1139.     for (trk = 0; target[trk] >= 0; trk++) {
  1140.         const int Trk = target[trk];
  1141.         const int beforeOctave = trkinf[Trk].octave;
  1142.         UWORD step, step1,stepincs;
  1143.         DWORD i;
  1144.         DWORD ofst = 0;
  1145.         int lastchord = 1;        /* last chord */
  1146.         int err;
  1147.         BYTE tieflag = 0;        /* become 1 when {..}nn& */
  1148.         DWORD renpnotes = 0;    /* renp notes (chord should be counted as 1 note) */
  1149.  
  1150.         if (trkinf[Trk].r->prev == NULL) {
  1151.             if (cominf->trackmode) {
  1152.                 cominf->trackmode = 0;
  1153.                 return zms;                    /* for .track ... { ... } */
  1154.             } else if (trkinf[Trk].renpnotes == 1) {
  1155.                 trkinf[Trk].renpnotes = 0;
  1156.                 return zms;                    /* for the data {} (NULL renpu) */
  1157.             } else {
  1158.                 zmserror("no { found..",line,linebuf,zms,0,1);
  1159.             }
  1160.         }
  1161.  
  1162.         zms = getStep(zms_, &step, trkinf[Trk].Step,&err,cominf);
  1163.         zms = skipSpcCr(zms);
  1164.         zms = checkOctaveChange(zms,trkinf,Trk);
  1165.         zms = skipSpcCr(zms);
  1166.         zms = set98Tie(zms,&step,trkinf[Trk].Step,cominf,&err);
  1167.         zms = skipSpcCr(zms);
  1168.         trkinf[Trk].total += step;
  1169.         if (*zms == '&') {
  1170.             tieflag = 1;
  1171.             zms++;
  1172.         }
  1173.  
  1174.         if (tieflag && beforeOctave != trkinf[Trk].octave && !warnoct) {
  1175.             zmserror("There is octave switch(es) between NOTE and TIE.",line,linebuf,zms,3,1);
  1176.             warnoct = 1;
  1177.         }
  1178.  
  1179.         {
  1180.             RENP *r = trkinf[Trk].r;
  1181.             int i;
  1182.  
  1183.             for (i = trkinf[Trk].renpnotes - 1; i > 0; i--) {
  1184.                 r = r->prev;
  1185.                 if (r->pflg != 2) {
  1186.                     renpnotes++;
  1187.                 }
  1188.             }
  1189.         }
  1190.  
  1191. /* ERROR handle is needed: for the case renpnotes == 0 */
  1192.         step1 = step / renpnotes;
  1193.         stepincs = step % renpnotes;
  1194.  
  1195.         incrementStepCounters(&trkinf[Trk],step);
  1196. #ifdef AAA
  1197.         if (trkinf[Trk].s->prev) {
  1198.             trkinf[Trk].s->step += step;
  1199.         }
  1200. #endif
  1201.  
  1202.         for (i = trkinf[Trk].renpnotes - 1; i > 0; i--) {
  1203.             UWORD step_ = step1;
  1204.             UWORD step0 = step1;
  1205.             /* UWORD stepold; */
  1206.             UWORD gateold;
  1207.             UBYTE *RenpuStepPos;
  1208.             UBYTE note;
  1209.             int delta;
  1210.             UWORD delay;
  1211.  
  1212.             if ( i < trkinf[Trk].renpnotes - 1 && trkinf[Trk].r->pflg) {
  1213.                 lastchord = 0;
  1214.             }
  1215.  
  1216.             trkinf[Trk].r = trkinf[Trk].r->prev;
  1217.             RenpuStepPos = trkdata[Trk].zmdbuf + trkinf[Trk].r->step;
  1218.             note = *(RenpuStepPos - 1);
  1219.             efree(trkinf[Trk].r->next,"trkinf[Trk].r->next");
  1220.  
  1221.             delay = getWord(RenpuStepPos);        /* for chord */
  1222.             if (i <= stepincs) {
  1223.                 step_++;
  1224.                 step0++;
  1225.             }
  1226.  
  1227. #ifdef A
  1228.             stepold = getWord(RenpuStepPos);
  1229.             if (cominf->renpmode == 1 && trkinf[Trk].r->pflg == 0) {
  1230.                 *RenpuStepPos = step_;
  1231.             } else {
  1232.                 putWord(RenpuStepPos, step_);
  1233.             }
  1234. #endif
  1235. /* fprintf(stderr,"pflg==%d",trkinf[Trk].r->pflg); */
  1236.             if (trkinf[Trk].r->pflg == 2) {
  1237.                                             /* chord, but isn't the last note */
  1238.                 step_ = delay;                /* getWord(RenpuStepPos); */
  1239. /* fprintf(stderr,"(d=%d)",delay); */
  1240.             }
  1241.             delta = putZvar(RenpuStepPos, step_);
  1242. /* fprintf(stderr,"[%d/",step_); */
  1243. #ifdef A
  1244.             if (trkinf[Trk].r->pflg == 1) {                            /* portament */
  1245.                 WORD br = 0,add,cor,cor0 = 0;
  1246.                 UWORD j, delayold;
  1247.  
  1248.                 delayold = getWord(RenpuStepPos + 4);
  1249.                 add = getWord(RenpuStepPos + 6);            /* get bend range */
  1250.                 cor = *(RenpuStepPos + 8);
  1251.                 for (j = 0; j < stepold - delayold; j++) {
  1252.                     br += add;
  1253.                     cor0 += cor;
  1254.                     if (cor0 > 0xFF) {
  1255.                         br++;
  1256.                         cor0 -= 0x100;
  1257.                     }
  1258.                 }
  1259.  
  1260.                 step_ -= delayold;                            /* make new add/cor */
  1261.                 /* br  = (note[1] - note[0]) * 683; */        /* bend range */
  1262.                 makePortBresemhamPara(br,&add,&cor,step_);
  1263.  
  1264.                 putWord(RenpuStepPos + 6, add);            /* set new add/cor */
  1265.                 *(RenpuStepPos + 8) = cor & 0xFF;
  1266.             }
  1267. #endif
  1268. #ifdef A
  1269.             if (cominf->renpmode == 1 && trkinf[Trk].r->pflg == 0) {
  1270.                 gateold = *(RenpuStepPos + 1);
  1271.                 if (gateold == 0xFF) {
  1272.                     gateold = 0x8000;
  1273.                 }
  1274.             } else {
  1275.                 gateold = getWord(RenpuStepPos + 2);
  1276.             }
  1277. #endif
  1278.  
  1279. /* gateold = getZvar(RenpuStepPos + 2); */
  1280.             gateold = getWord(RenpuStepPos + 2);
  1281. /* fprintf(stderr,"(%.2x)/",gateold); */
  1282.             if (i == trkinf[Trk].renpnotes - 1 && tieflag) {        /* {..}nn& */
  1283.                 gateold = 0x8000;
  1284. #ifdef A
  1285.                 if (cominf->renpmode == 1 && trkinf[Trk].r->pflg == 0) {
  1286.                     *(RenpuStepPos + 1) = gateold;
  1287.                 } else {
  1288.                     putWord(RenpuStepPos + 2, gateold);
  1289.                 }
  1290. #endif
  1291. /*
  1292.                 putZvar(RenpuStepPos + delta, 0x8000);
  1293. */
  1294.             }
  1295.  
  1296.  
  1297. /*
  1298. delayを含む和音のgate値の再計算はどうする？
  1299. */
  1300.  
  1301.             if (gateold != 0x8000) {                        /* not TIE */
  1302.                 WORD qvar = trkinf[Trk].r->qvar;
  1303.                 BYTE qrel = trkinf[Trk].r->qrelflg;
  1304.                 /* UWORD gate; */
  1305.  
  1306.                 if (trkinf[Trk].r->pflg == 2) {                /* chord */
  1307.                     step_ = step0 - delay;
  1308.                 }
  1309.  
  1310.                 gateold = getGate2(qvar,qrel,step_,trkinf[Trk].gtreso);
  1311. #ifdef A
  1312.                 if (cominf->renpmode == 1 && trkinf[Trk].r->pflg == 0) {
  1313.                     *(RenpuStepPos + 1) = gate;
  1314.                 } else {
  1315.                     putWord(RenpuStepPos + 2, gate);
  1316.                 }
  1317. #endif
  1318.             }
  1319.             delta += putZvar(RenpuStepPos + delta, gateold);
  1320.             trkinf[Trk].r->pflg = 0;
  1321. /*fprintf(stderr,"%d]\n",gateold); */
  1322.  
  1323.             if (delta && delta < 4) {
  1324. /*const UBYTE *p = RenpuStepPos; */
  1325. /*fprintf(stderr,"[%.2X %.2X %.2X %.2X]",*(p + delta), *(p+delta+1), *(p+delta+2),*(p+delta+3));*/
  1326. /*fprintf(stderr,"(%.2X %.2X %.2X)",*(p+4), *(p+5), *(p+6)); */
  1327.  
  1328.                 memmove(RenpuStepPos + delta,
  1329.                         RenpuStepPos + 4,
  1330.                         trkdata[Trk].zmd - (RenpuStepPos + 4) );
  1331.                 ofst += (4 - delta);
  1332.  
  1333. /*fprintf(stderr,"(%.2X %.2X %.2X %.2X)",*(p + delta), *(p+delta+1), *(p+delta+2),*(p+delta+3)); */
  1334.             }
  1335.  
  1336.  
  1337.             if (lastchord) {
  1338.                 CHKCHORD *c = trkinf[Trk].c;
  1339.  
  1340.                 while (c->next != NULL) {
  1341.                     c->renputieflg = 0;
  1342.                     c = c->next;
  1343.                 }
  1344.  
  1345.                 c = trkinf[Trk].c;
  1346.                 while (c->next != NULL) {
  1347.                     if (c->note == note) {    /* if there is tie-d tone before */
  1348.                         c->renputieflg = 1;
  1349.                     }
  1350.                     c = c->next;
  1351.                 }
  1352.  
  1353.                 c = trkinf[Trk].c;
  1354.                 while (c->next != NULL) {
  1355.                     if (c->renputieflg) {    /* */
  1356.                         c->gatepos -= delta;
  1357.                     }
  1358.                     c = c->next;
  1359.                 }
  1360.             }
  1361.  
  1362.  
  1363.         }
  1364.         trkinf[Trk].renpnotes = 0;
  1365.         trkdata[Trk].zmd -= ofst;
  1366.     }
  1367.  
  1368.     return zms;
  1369. }
  1370.  
  1371.  
  1372.  
  1373. #ifdef A
  1374. void makePortBresemhamPara(WORD br,WORD *add,WORD *cor,UWORD step)
  1375. {
  1376.     if (step) {
  1377.         DWORD tempcor;
  1378.  
  1379.         if (br < 0) {
  1380.             br = -br;
  1381.             *add = -(br / step);
  1382.         } else {
  1383.             *add = br / step;
  1384.         }
  1385.  
  1386.         tempcor  = ((DWORD)br % step) * 256;
  1387.         br       = tempcor % step;        /* br: temporary */
  1388.         tempcor /= step;
  1389.         if (br) {
  1390.             tempcor++;
  1391.         }
  1392.         *cor = tempcor;
  1393.     } else {
  1394.         *add = *cor = 0;
  1395.     }
  1396. }
  1397. #endif
  1398.  
  1399.  
  1400. void setVelocitySequenceMode(TRKINF *trkinf,const BYTE trk,int mode)
  1401. {
  1402.     trkinf[trk].velou.relflg[0] = mode;
  1403. }
  1404.  
  1405.  
  1406. inline void recoverSpecialVelocity(TRKINF *trkinf, int Trk)
  1407. {
  1408.     if (trkinf[Trk].spvelomode) {
  1409.         trkinf[Trk].spvelomode = 0;
  1410.     }
  1411. }
  1412.  
  1413.  
  1414. UBYTE *checkOctaveChange(UBYTE *zms,TRKINF *trkinf,const int Trk)
  1415. {
  1416.     while (*zms == '<' || *zms == '>' || *zms == 'o' || *zms == 'O') {
  1417.         switch (*zms++) {
  1418.             case 'o':
  1419.             case 'O':
  1420.                 {
  1421.                     DWORD tmpDWORD;
  1422.                     zms = get1AbsPara(zms,&tmpDWORD,-1,9,
  1423.                             "octave parameter is out of range(-1 - 9).",
  1424.                             "'o'(octave set) must be followed to its parameter.");
  1425.                     trkinf[Trk].octave = tmpDWORD;
  1426.                 }
  1427.                 break;
  1428.             case '<':
  1429.                 trkinf[Trk].octave++;
  1430.                 break;
  1431.             case '>':
  1432.                 trkinf[Trk].octave--;
  1433.                 break;
  1434.         }
  1435.         if (trkinf[Trk].octave < -1 || 9 < trkinf[Trk].octave) {
  1436.             zmserror("octave parameter is out of range(-1 - 9).",line,linebuf,zms,0,1);
  1437.         }
  1438.     }
  1439.     return zms;
  1440. }
  1441.  
  1442.  
  1443. void incrementStepCounters(TRKINF *trkinf, UWORD step)
  1444. {
  1445.     if (!(trkinf->renpnotes)) {
  1446.         trkinf->total += step;
  1447. /*
  1448.         if (trkinf->s->prev) {
  1449.             trkinf->s->step += step;
  1450.         }
  1451. */
  1452.     }
  1453. }
  1454.  
  1455.  
  1456. int putZvar(UBYTE *zmd, DWORD var)
  1457. {
  1458.     if (var < 128) {
  1459.         *zmd = var;
  1460.         return 1;
  1461.     } else if (var == 0xFFFF || var == 0x8000) {
  1462.         putWord(zmd, var);
  1463.         return 2;
  1464.     } else if (var > 0x8000) {
  1465.         putWord(zmd, var);
  1466.         return 2;
  1467.     } else {
  1468.         putWord(zmd, var + 0x8000);
  1469.         return 2;
  1470.     }
  1471. }
  1472.  
  1473.  
  1474. DWORD getZvar(UBYTE *zmd)
  1475. {
  1476.     DWORD ret;
  1477.  
  1478.     if (*zmd < 0x80) {
  1479.         ret = *zmd;
  1480.     } else if (*zmd == 0x80) {
  1481.         ret = getWord(zmd);
  1482.     } else {
  1483.         ret = (*zmd - 0x80) * 0x100 + *(zmd + 1);
  1484.     }
  1485.     return ret;
  1486. }
  1487.  
  1488.  
  1489. int putStepGate(UBYTE *zmd, RENP *r, UWORD step, UWORD gate)
  1490. {
  1491.     if (r) {        /* always 2byte while renpu */
  1492.         putWord(zmd,     step);
  1493.         putWord(zmd + 2, gate);
  1494. /* fprintf(stderr,"[%d / %d]\n",step,gate); */
  1495.         return 4;
  1496.     } else {
  1497.         const UBYTE *zmd_ = zmd;
  1498.         zmd += putZvar(zmd, step);
  1499.         zmd += putZvar(zmd, gate);
  1500.         return zmd - zmd_;
  1501.     }
  1502. }
  1503.  
  1504. void freeAllChord(CHKCHORD *c)
  1505. {
  1506.     if (c->next) {
  1507.         CHKCHORD *c_org = c;
  1508.         c = c->next;
  1509.         do {
  1510.             CHKCHORD *n = c->next;
  1511.             efree(c,"c");
  1512.             c = n;
  1513.         } while (c != NULL);
  1514.         c = c_org;
  1515.     }
  1516.     c->next = c->prev = NULL;
  1517.     c->note = -1;
  1518. }
  1519.  
  1520. UBYTE *getChordGatePos(UBYTE *zmdbuf, DWORD gatepos, DWORD renpnotes)
  1521. {
  1522.     UBYTE *CHORDGATEPOS;
  1523.  
  1524.     CHORDGATEPOS = zmdbuf + gatepos + 1;
  1525.     CHORDGATEPOS += (*CHORDGATEPOS >= 0x80 || renpnotes)? 2 : 1;
  1526.     if (renpnotes && *(CHORDGATEPOS - 1) == 0x80 && *CHORDGATEPOS == 0x00) {
  1527.             CHORDGATEPOS--;
  1528.     }
  1529.  
  1530.     return CHORDGATEPOS;
  1531. }
  1532.